// RAP [bm]: no needed
///*******************************************************************************
// * Copyright (c) 2000, 2010 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// * Bruno Haible haible@ilog.fr - bug 228890
// *******************************************************************************/
//package org.eclipse.ui.internal.handlers;
//
//import java.lang.reflect.InvocationTargetException;
//import java.lang.reflect.Method;
//import org.eclipse.core.commands.AbstractHandler;
//import org.eclipse.core.commands.ExecutionEvent;
//import org.eclipse.core.commands.ExecutionException;
//import org.eclipse.core.runtime.IConfigurationElement;
//import org.eclipse.core.runtime.IExecutableExtension;
//import org.eclipse.swt.SWT;
//import org.eclipse.swt.widgets.Composite;
//import org.eclipse.swt.widgets.Control;
//import org.eclipse.swt.widgets.Display;
//import org.eclipse.swt.widgets.Event;
//import org.eclipse.swt.widgets.Listener;
//import org.eclipse.ui.internal.ExceptionHandler;
//
///**
// * Handles the cut command in both dialogs and windows. This handler is enabled
// * if the focus control supports the "cut" method.
// *
// * @since 3.0
// */
//public class WidgetMethodHandler extends AbstractHandler implements
// IExecutableExtension {
//
// /**
// * The parameters to pass to the method this handler invokes. This handler
// * always passes no parameters.
// */
// protected static final Class[] NO_PARAMETERS = new Class[0];
//
// public WidgetMethodHandler() {
// display = Display.getCurrent();
// if (display != null) {
// focusListener = new Listener() {
// public void handleEvent(Event event) {
// updateEnablement();
// }
// };
// display.addFilter(SWT.FocusIn, focusListener);
// }
// }
//
// void updateEnablement() {
// boolean rc = isHandled();
// if (rc != isEnabled()) {
// setBaseEnabled(rc);
// }
// }
//
// /*
// * (non-Javadoc)
// *
// * @see
// * org.eclipse.core.commands.AbstractHandler#setEnabled(java.lang.Object)
// */
// public void setEnabled(Object evaluationContext) {
// updateEnablement();
// }
//
// /**
// * The name of the method to be invoked by this handler. This value should
// * never be <code>null</code>.
// */
// protected String methodName;
// private Listener focusListener;
// private Display display;
//
// public Object execute(final ExecutionEvent event) throws ExecutionException {
// final Method methodToExecute = getMethodToExecute();
// if (methodToExecute != null) {
// try {
// final Control focusControl = Display.getCurrent()
// .getFocusControl();
// if ((focusControl instanceof Composite)
// && ((((Composite) focusControl).getStyle() & SWT.EMBEDDED) != 0)) {
// /*
// * Okay. Have a seat. Relax a while. This is going to be a
// * bumpy ride. If it is an embedded widget, then it *might*
// * be a Swing widget. At the point where this handler is
// * executing, the key event is already bound to be
// * swallowed. If I don't do something, then the key will be
// * gone for good. So, I will try to forward the event to the
// * Swing widget. Unfortunately, we can't even count on the
// * Swing libraries existing, so I need to use reflection
// * everywhere. And, to top it off, I need to dispatch the
// * event on the Swing event queue, which means that it will
// * be carried out asynchronously to the SWT event queue.
// */
// try {
// final Object focusComponent = getFocusComponent();
// if (focusComponent != null) {
// Runnable methodRunnable = new Runnable() {
// public void run() {
// try {
// methodToExecute.invoke(focusComponent,
// null);
// } catch (final IllegalAccessException e) {
// // The method is protected, so do
// // nothing.
// } catch (final InvocationTargetException e) {
// /*
// * I would like to log this exception --
// * and possibly show a dialog to the
// * user -- but I have to go back to the
// * SWT event loop to do this. So, back
// * we go....
// */
// focusControl.getDisplay().asyncExec(
// new Runnable() {
// public void run() {
// ExceptionHandler
// .getInstance()
// .handleException(
// new ExecutionException(
// "An exception occurred while executing " //$NON-NLS-1$
// + methodToExecute
// .getName(),
// e
// .getTargetException()));
// }
// });
// }
// }
// };
//
// swingInvokeLater(methodRunnable);
// }
// } catch (final ClassNotFoundException e) {
// // There is no Swing support, so do nothing.
//
// } catch (final NoSuchMethodException e) {
// // The API has changed, which seems amazingly unlikely.
// throw new Error("Something is seriously wrong here"); //$NON-NLS-1$
// }
//
// } else {
//
// methodToExecute.invoke(focusControl, null);
// }
//
// } catch (IllegalAccessException e) {
// // The method is protected, so do nothing.
//
// } catch (InvocationTargetException e) {
// throw new ExecutionException(
// "An exception occurred while executing " //$NON-NLS-1$
// + methodToExecute.getName(), e
// .getTargetException());
//
// }
// }
//
// return null;
// }
//
// /**
// * Invoke a runnable on the swing EDT.
// *
// * @param methodRunnable
// * @throws ClassNotFoundException
// * @throws NoSuchMethodException
// * @throws IllegalAccessException
// * @throws InvocationTargetException
// */
// protected void swingInvokeLater(Runnable methodRunnable)
// throws ClassNotFoundException, NoSuchMethodException,
// IllegalAccessException, InvocationTargetException {
// final Class swingUtilitiesClass = Class
// .forName("javax.swing.SwingUtilities"); //$NON-NLS-1$
// final Method swingUtilitiesInvokeLaterMethod = swingUtilitiesClass
// .getMethod("invokeLater", //$NON-NLS-1$
// new Class[] { Runnable.class });
// swingUtilitiesInvokeLaterMethod.invoke(swingUtilitiesClass,
// new Object[] { methodRunnable });
// }
//
// /**
// * Find the swing focus component, if it is available.
// *
// * @return Hopefully, the swing focus component, but it can return
// * <code>null</code>.
// * @throws ClassNotFoundException
// * @throws NoSuchMethodException
// * @throws IllegalAccessException
// * @throws InvocationTargetException
// */
// protected Object getFocusComponent() throws ClassNotFoundException,
// NoSuchMethodException, IllegalAccessException,
// InvocationTargetException {
// /*
// * Before JRE 1.4, one has to use
// * javax.swing.FocusManager.getCurrentManager().getFocusOwner(). Since
// * JRE 1.4, one has to use
// * java.awt.KeyboardFocusManager.getCurrentKeyboardFocusManager
// * ().getFocusOwner(); the use of the older API would install a
// * LegacyGlueFocusTraversalPolicy which causes endless recursions in
// * some situations.
// */
// Class keyboardFocusManagerClass = null;
// try {
// keyboardFocusManagerClass = Class
// .forName("java.awt.KeyboardFocusManager"); //$NON-NLS-1$
// } catch (ClassNotFoundException e) {
// // switch to the old guy
// }
// if (keyboardFocusManagerClass != null) {
// // Use JRE 1.4 API
// final Method keyboardFocusManagerGetCurrentKeyboardFocusManagerMethod = keyboardFocusManagerClass
// .getMethod("getCurrentKeyboardFocusManager", null); //$NON-NLS-1$
// final Object keyboardFocusManager = keyboardFocusManagerGetCurrentKeyboardFocusManagerMethod
// .invoke(keyboardFocusManagerClass, null);
// final Method keyboardFocusManagerGetFocusOwner = keyboardFocusManagerClass
// .getMethod("getFocusOwner", null); //$NON-NLS-1$
// final Object focusComponent = keyboardFocusManagerGetFocusOwner
// .invoke(keyboardFocusManager, null);
// return focusComponent;
// }
// // Use JRE 1.3 API
// final Class focusManagerClass = Class
// .forName("javax.swing.FocusManager"); //$NON-NLS-1$
// final Method focusManagerGetCurrentManagerMethod = focusManagerClass
// .getMethod("getCurrentManager", null); //$NON-NLS-1$
// final Object focusManager = focusManagerGetCurrentManagerMethod
// .invoke(focusManagerClass, null);
// final Method focusManagerGetFocusOwner = focusManagerClass
// .getMethod("getFocusOwner", null); //$NON-NLS-1$
// final Object focusComponent = focusManagerGetFocusOwner
// .invoke(focusManager, null);
// return focusComponent;
//
// }
//
// public final boolean isHandled() {
// return getMethodToExecute() != null;
// }
//
// /**
// * Looks up the method on the focus control.
// *
// * @return The method on the focus control; <code>null</code> if none.
// */
// protected Method getMethodToExecute() {
// Display display = Display.getCurrent();
// if (display == null)
// return null;
// final Control focusControl = display.getFocusControl();
// Method method = null;
//
// if (focusControl != null) {
// final Class clazz = focusControl.getClass();
// try {
// method = clazz.getMethod(methodName, NO_PARAMETERS);
// } catch (NoSuchMethodException e) {
// // Fall through...
// }
// }
//
// if ((method == null)
// && (focusControl instanceof Composite)
// && ((((Composite) focusControl).getStyle() & SWT.EMBEDDED) != 0)) {
// /*
// * We couldn't find the appropriate method on the current focus
// * control. It is possible that the current focus control is an
// * embedded SWT composite, which could be containing some Swing
// * components. If this is the case, then we should try to pass
// * through to the underlying Swing component hierarchy. Insha'allah,
// * this will work.
// */
// try {
// final Object focusComponent = getFocusComponent();
// if (focusComponent != null) {
// final Class clazz = focusComponent.getClass();
//
// try {
// method = clazz.getMethod(methodName, NO_PARAMETERS);
// } catch (NoSuchMethodException e) {
// // Do nothing.
// }
// }
// } catch (final ClassNotFoundException e) {
// // There is no Swing support, so do nothing.
//
// } catch (final NoSuchMethodException e) {
// // The API has changed, which seems amazingly unlikely.
// throw new Error("Something is seriously wrong here"); //$NON-NLS-1$
// } catch (IllegalAccessException e) {
// // The API has changed, which seems amazingly unlikely.
// throw new Error("Something is seriously wrong here"); //$NON-NLS-1$
// } catch (InvocationTargetException e) {
// // The API has changed, which seems amazingly unlikely.
// throw new Error("Something is seriously wrong here"); //$NON-NLS-1$
// }
// }
//
// return method;
// }
//
// /*
// * (non-Javadoc)
// *
// * @see
// * org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org
// * .eclipse.core.runtime.IConfigurationElement, java.lang.String,
// * java.lang.Object)
// */
// public void setInitializationData(IConfigurationElement config,
// String propertyName, Object data) {
// // The data is really just a string (i.e., the method name).
// methodName = data.toString();
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.core.commands.AbstractHandler#dispose()
// */
// public void dispose() {
// if (display!=null && !display.isDisposed()) {
// display.removeFilter(SWT.FocusIn, focusListener);
// }
// display = null;
// focusListener = null;
// }
//}